// for-each loop
// from array start to finish
// read only. cannot modify the array
// Use this if you just need to go thru the entire array
// and examine each element individually
public int countEvens(int[] nums) {
  int count = 0;
  
  for (int n : nums) {
    if (n % 2 == 0) {
      count = count + 1;
    }
  }
  
  return count;
}

// indexed for-loop
// Use this when you need to examine adjacent elements
// TOGETHER, or when you want go thru a subsection of the array
public int countEvens1(int[] nums) {
  int count = 0;
  
  for (int i=0; i<nums.length; i++) {
    int n = nums[i];
    if (n % 2 == 0) {
      count = count + 1;
    }
  }
  
  return count;
}

public int bigDiff(int[] nums) {
  int largest = nums[0];
  int smallest = nums[0];
  
  for (int n : nums) {
    largest = Math.max(largest, n)  ;
    smallest = Math.min(smallest, n)  ;
  }
  
  int diff = largest-smallest;
  return diff;
}

public int centeredAverage(int[] nums) {
  int largest = nums[0];
  int smallest = nums[0];
  int sum = 0;
  
  for (int n : nums) {
    largest = Math.max(largest, n)  ;
    smallest = Math.min(smallest, n)  ;
    sum = sum + n;
  }
  
  sum = sum - (largest + smallest);
  int count = nums.length-2;
  int average = sum / count;
  return average;  
}

public boolean has22(int[] nums) {
  for (int i=0; i+1<nums.length; i++) {
    int n1 = nums[i]; 
    int n2 = nums[i+1];
    if (n1 == 2 && n2 == 2) {
      return true;
    }
  }
  
  return false;
}

public boolean has22(int[] nums) {
  boolean answer = false;
  
  for (int i=0; i+1<nums.length; i++) {
    int n1 = nums[i]; 
    int n2 = nums[i+1];
    if (n1 == 2 && n2 == 2) {
      answer = true;
      break;
    }
  }
  
  return answer;
}

/*
i   i+1
0   1
1   2
2   3

*/

public boolean lucky13(int[] nums) {
  for (int n : nums) {
    if (n == 1 || n == 3)   {
      return false;
    }
  }
  return true;
}

public boolean lucky13(int[] nums) {
  int count1 = 0;
  int count3 = 0;
  
  for (int n : nums) {
    if (n == 1) {
      count1++; // count1 = count1 + 1;
    }
    if (n == 3) {
      count3++;
    }
  }
  
  boolean neither = false;
  if (count1 == 0 && count3 == 0) {
    neither = true;
  }
  return neither;
}

public boolean sum28(int[] nums) {
  boolean answer = false;

  int sum2s = 0;
  for (int n : nums)   {
    if (n == 2) {
      sum2s = sum2s + 2;
    }
  }
  
  if (sum2s == 8) {
    answer = true;
  }
  return answer;
}

public boolean more14(int[] nums) {
  int count1 = 0;
  int count4 = 0;
  
  for (int n : nums) {
    if (n == 1) {
      count1 = count1 + 1;
    }
    if (n == 4) {
      count4 = count4 + 1;
    }
  }
  
  boolean more = false;
  if (count1 > count4) {
    more = true;
  }
  return more;
}

public boolean only14(int[] nums) {
  for (int n : nums) {
    boolean numIs1or4 = (n == 1 || n == 4);
    if ( !numIs1or4 ) {
      return false;
    }
  }

  return true;
}

public boolean only14_1(int[] nums) {
  boolean answer = false;
  
  int count14 = 0;
  for (int n : nums) {
    if (n == 1 || n == 4) {
      count14 = count14 + 1;
    }
  }
  if (count14 == nums.length) {
    answer = true;
  }
  
  return answer;
}

public boolean no14(int[] nums) {
  
  boolean contains1 = false;
  boolean contains4 = false;
  for (int n : nums) {
    if (n == 1) {
      contains1 = true;
    }
    if (n == 4) {
      contains4 = true;
    }
  }
  
  boolean answer = false;
  if (!contains1 || !contains4) {
    answer = true;
  }

  return answer;
}

public boolean isEverywhere(int[] nums, int val) {
  for (int i=0; i+1<nums.length; i++) {
    int n1 = nums[i];
    int n2 = nums[i+1];
    boolean eitherIsVal = (n1 == val || n2 == val);
    if (!eitherIsVal) {
      return false;
    }
  }
  return true;
}

public boolean either24(int[] nums) {
  boolean found2NextTo2 = false;
  boolean found4NextTo4 = false;

  for (int i=0; i+1<nums.length; i++)   {
    int n1 = nums[i];
    int n2 = nums[i+1];
    if (n1 == 2 && n2 ==2) {
      found2NextTo2 = true;
    }
    if (n1 == 4 && n2 ==4) {
      found4NextTo4 = true;
    }
  }
  
  boolean answer = false;  
  if (found2NextTo2 && !found4NextTo4) {
    answer = true;
  }
  if (!found2NextTo2 && found4NextTo4) {
    answer = true;
  }
  return answer;
}

public boolean either24_1(int[] nums) {
  boolean found2NextTo2 = false;
  boolean found4NextTo4 = false;

  for (int i=0; i+1<nums.length; i++)   {
    int n1 = nums[i];
    int n2 = nums[i+1];
    if (n1 == 2 && n2 ==2) {
      found2NextTo2 = true;
    }
    if (n1 == 4 && n2 ==4) {
      found4NextTo4 = true;
    }
  }
  
  boolean answer = false;  
  // exclusive OR (^)
  if (found2NextTo2 ^ found4NextTo4) {
    answer = true;
  }
  return answer;
}

public int matchUp(int[] a, int[] b) {
  int count = 0;
  for (int i=0; i<a.length; i++) {
    int n1 = a[i];
    int n2 = b[i];
    int diff = Math.abs(n1-n2);
    if (n1 != n2 && diff <= 2) {
      count = count + 1;
    }
  }
  return count;
}

public int matchUp_1(int[] a, int[] b) {
  int count = 0;
  for (int i=0; i<a.length; i++) {
    int n1 = a[i];
    int n2 = b[i];
    int diff = Math.abs(n1-n2);
    if (diff == 1 || diff == 2) {
      count = count + 1;
    }
  }
  return count;
}

public int matchUp_2(int[] a, int[] b) {
  int count = 0;
  for (int i=0,j=0; i<a.length & j<b.length; i++,j++) {
    int n1 = a[i];
    int n2 = b[j];
    int diff = Math.abs(n1-n2);
    if (n1 != n2 && diff <= 2) {
      count = count + 1;
    }
  }
  return count;
}

public boolean has77(int[] nums) {
  for (int i=0; i+1<nums.length; i++)  {
    int n1 = nums[i];
    int n2 = nums[i+1];
    if (n1 == 7 && n2 == 7) {
      return true;
    }
  }
  for (int i=0; i+2<nums.length; i++)  {
    int n1 = nums[i];
    int n3 = nums[i+2];
    if (n1 == 7 && n3 == 7) {
      return true;
    }
  }
  return false;
}


public boolean has12(int[] nums) {
  int index1 = -1;
  for (int i=0; i<nums.length; i++) {
    int n = nums[i];
    if (n == 1) {
      index1 = i;
      break;
    }
  }
  
  if (index1 == -1) {
    return false;
  }

  for (int i=index1+1; i<nums.length; i++) {
    int n = nums[i];
    if (n == 2) {
      return true;
    }
  }
  
  return false;
}

public boolean has12(int[] nums) {
  int index1 = nums.length;
  for (int i=0; i<nums.length; i++) {
    int n = nums[i];
    if (n == 1) {
      index1 = i;
      break;
    }
  }
  
  for (int i=index1+1; i<nums.length; i++) {
    int n = nums[i];
    if (n == 2) {
      return true;
    }
  }
  
  return false;
}

// helper method
public int indexOf(int[] nums, int target) {
  for (int i=0; i<nums.length; i++)   {
    int n = nums[i];
    if (n == target) {
      return i;
    }
  }
  return -1;
}

// helper method
public int lastIndexOf(int[] nums, int target) {
  for (int i=nums.length-1; i>=0; i--)   {
    int n = nums[i];
    if (n == target) {
      return i;
    }
  }
  return -1;
}

public boolean has12(int[] nums) {
  int index1 = indexOf(nums, 1);
  int index2 = lastIndexOf(nums, 2);
  return ( index1 != -1 && index1 < index2 );
}

public boolean modThree(int[] nums) {
  for (int i=0; i+2<nums.length; i++) {
    int n1 = nums[i];
    int n2 = nums[i+1];
    int n3 = nums[i+2];
    if (n1 % 2 == 0 && n2 % 2 == 0 && n3 % 2 == 0) {
      return true;
    }
    if (n1 % 2 != 0 && n2 % 2 != 0 && n3 % 2 != 0) {
      return true;
    }
  }
  return false;
}

public boolean haveThree(int[] nums) {
  int count3 = 0;
  for (int n : nums) {
    if (n == 3) {
      count3++;
    }
  }

  for (int i=0; i+1<nums.length; i++) {
    int n1 = nums[i];
    int n2 = nums[i+1];
    if (n1 == 3 && n2 == 3) {
      return false;
    }
  }

  return count3 == 3;
}

public boolean twoTwo(int[] nums) {
  for (int i=0; i<nums.length; i++) {
    boolean ok = false;
    int n = nums[i];
    int prev = 0;
    int next = 0;
    if (i-1 >= 0) {
      prev = nums[i-1];
    }
    if (i+1 < nums.length) {
      next = nums[i+1];
    }
    if (n == 2 && prev != 2 && next != 2) {
      return false;
    }
  }
  return true;
}

public boolean tripleUp(int[] nums) {
  for (int i=0; i+2<nums.length; i++) {
    int n1 = nums[i];
    int n2 = nums[i+1];
    int n3 = nums[i+2];
    if (n1 + 1 == n2 && n2 + 1 == n3) {
      return true;
    }
  }
  return false;
}

public int[] shiftLeft(int[] a) {
  int len = a.length;
  int[] b = new int[len];
  
  // i is for a, j is for b
  for (int i=1,j=0; i<a.length; i++,j++) {
    b[j] = a[i];
  }
  if (len > 0) {
    b[len-1] = a[0];
  }
  return b;
}


public int[] pre4(int[] nums) {
  int len = 0;
  for (int n : nums) {
    if (n == 4) {
      break;
    }
    len = len + 1;
  }

// either one of these will work  
// int[] list = Arrays.copyOfRange(nums,0,len);
  int[] list = Arrays.copyOf(nums,len);
  return list;
}

public int[] pre4(int[] nums) {
  int len = 0;
  for (int n : nums) {
    if (n == 4) {
      break;
    }
    len = len + 1;
  }
  
  int[] list = new int[len];
  for (int i=0; i<len; i++) {
    list[i] = nums[i];
  }
  return list;
}


public int[] evenOdd(int[] nums) {
  int len = nums.length;
  int[] list = new int[len];
  
  int j = 0;
  for (int i=0; i<nums.length; i++) {
    int n = nums[i];
    if (n % 2 == 0) {
      list[j] = nums[i];
      j++;
    }
  }
  
  for (int i=0; i<nums.length; i++) {
    int n = nums[i];
    if (n % 2 != 0) {
      list[j] = nums[i];
      j++;
    }
  }

  return list;
}

public int[] evenOdd(int[] nums) {
  int len = nums.length;
  int[] list = new int[len];
  
  int j = 0; // even #s, add from the beginning
  int k = len-1; // odd #s, add from the end
  for (int i=0; i<nums.length; i++) {
    int n = nums[i];
    if (n % 2 == 0) { // even
      list[j] = nums[i];
      j++;
    }
    else { // odd
      list[k] = nums[i];
      k--;
    }
  }
  
  return list;
}